home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / cpicker / pixedit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-23  |  16.8 KB  |  650 lines
  1. /*
  2.  * pixedit.c - Pixel color editor for X11
  3.  * 
  4.  * Author:    Mike Yang (mikey@sgi.com)
  5.  *        Silicon Graphics, Inc.
  6.  * Date:    Mon Jul 29 1991
  7.  * Copyright (c) 1988, 1991 Mike Yang
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <math.h>
  12. #include "Cpick.h"
  13. #include <X11/Xproto.h>
  14. #include <X11/cursorfont.h>
  15. #include <Xm/Form.h>
  16. #include <Xm/MessageB.h>
  17.  
  18. #define HELP_STRING    "Pixedit, a colormap editing utility.  Mike Yang, Silicon Graphics, mikey@sgi.com"
  19.  
  20. /* #define USE_COLORS    /* define to make the scale labels colored */
  21.  
  22. /* We do this because most servers support only the upper 8 bits for RGB */
  23. #define SAME_COLOR(x,y)    ((x)/256 == (y)/256 || (x)/256+1 == (y)/256 || (x)/256 == (y)/256+1)
  24.  
  25. XColor allocated, current;
  26. Widget realtop, toplevel, cpick, dialog;
  27. XColor mapv[MAXPIXELS];
  28. Colormap cmap;
  29. Boolean picking;
  30. int maxpixels, numpixels, numfree, realfree;
  31. unsigned long avail[MAXPIXELS], got[MAXPIXELS];
  32. char *argv0;
  33. Position choose_x = 200, choose_y = 200;
  34. XmColorProc colorProc;
  35. XColor fgColor, selectColor, topColor, bottomColor;
  36. Boolean doMotif, haveFg, haveSelect, haveTop, haveBottom;
  37.  
  38. typedef unsigned long (*PixProc)();
  39.  
  40. struct vals {
  41.   int ih, iw, x0, y0, rownum;
  42.   PixProc pix;
  43. } gval, nval;
  44.  
  45. Arg setargs[] = {
  46.   {XmNallocated, (XtArgVal) &allocated},
  47. };
  48.  
  49. static XrmOptionDescRec cmdOptions[] = {
  50.   {
  51.     "-motif", ".motif", XrmoptionIsArg, NULL,
  52.   },
  53.   {
  54.     "-noMotif", ".noMotif", XrmoptionIsArg, NULL,
  55.   },
  56.   {
  57.     "-nomotif", ".noMotif", XrmoptionIsArg, NULL,
  58.   },
  59. };
  60.  
  61. static Arg args[20];
  62. static int count;
  63.  
  64. usage()
  65. {
  66.     fprintf (stderr,
  67.         "usage:  cpicker [-options ...]\n\n");
  68.     fprintf (stderr,
  69.         "where options include:\n");
  70.     fprintf (stderr,
  71.         "    -display host:dpy    X server to contact\n");
  72.     fprintf (stderr,
  73.     "    -motif               enable Motif color matching (the default)\n");
  74.     fprintf (stderr,
  75.     "    -noMotif             disable Motif color matching\n");
  76. }
  77.  
  78. void postDialog(msg)
  79. char *msg;
  80. {
  81.   XmString xs;
  82.  
  83.   xs = XmStringCreateSimple(msg);
  84.   count = 0;
  85.   XtSetArg(args[count], XmNmessageString, xs);  count++;
  86.   XtSetValues(dialog, args, count);
  87.   XtManageChild(dialog);
  88. }
  89.  
  90. Dimension getD(w, s)
  91. Widget w;
  92. String s;
  93. {
  94.   Dimension result;
  95.   Arg args[1];
  96.   int v;
  97.  
  98.   XtSetArg(args[0],s,(XtArgVal) &result);
  99.   XtGetValues(w, args, XtNumber(args));
  100.   v = result;
  101.  
  102.   return(v);
  103. }
  104.  
  105. Position getP(w, s)
  106. Widget w;
  107. String s;
  108. {
  109.   Position result;
  110.   Arg args[1];
  111.   int v;
  112.  
  113.   XtSetArg(args[0],s,(XtArgVal) &result);
  114.   XtGetValues(w, args, XtNumber(args));
  115.   v = result;
  116.  
  117.   return(v);
  118. }
  119.  
  120. saveCurrent()
  121. {
  122.   current.red = allocated.red;
  123.   current.green = allocated.green;
  124.   current.blue = allocated.blue;
  125.   XStoreColor(XtDisplay(toplevel), cmap, ¤t);
  126. }
  127.  
  128. restoreCmap()
  129. {
  130.   Display *dpy;
  131.   int screen, each, each2, count;
  132.   Boolean found;
  133.   XColor copy[MAXPIXELS];
  134.  
  135.   dpy = XtDisplay(toplevel);
  136.   screen = XDefaultScreen(XtDisplay(toplevel));
  137.  
  138.   count = 0;
  139.   for (each=0; each<numpixels; each++) {
  140.     found = FALSE;
  141.     for (each2=0; (each2<=realfree) && !found; each2++) {
  142.       if (avail[each2] == got[each])
  143.     found = TRUE;
  144.     }
  145.     if (!found)
  146.       copy[count++] = mapv[got[each]];
  147.   }
  148.  
  149.   XStoreColors(dpy,cmap,copy,count);
  150.   XInstallColormap(dpy,cmap);
  151.  
  152.   XStoreColors(dpy,cmap,copy,count);
  153.   XInstallColormap(dpy,cmap);
  154. }
  155.  
  156. doSelect(cmd, cdata, position)
  157.      Widget cmd;
  158.      XtPointer cdata;
  159.      float position;
  160. {
  161.   Window chosen, ignorew, last;
  162.   int ignore;
  163.   unsigned int ignoreu;
  164.   XEvent ev;
  165.   int x, y, each, each2;
  166.   unsigned long newpix;
  167.   Widget bframe;
  168.   XColor bgColor;
  169.   Boolean first;
  170.  
  171.   if (cdata != NULL) {
  172.     postDialog("Click on a pixel to edit its colormap value.");
  173.   }
  174.   haveFg = haveSelect = haveTop = haveBottom = False;
  175.   picking = TRUE;
  176.   XGrabPointer(XtDisplay(toplevel),
  177.            XRootWindowOfScreen(XDefaultScreenOfDisplay(XtDisplay(toplevel))),
  178.            FALSE,
  179.            ButtonPressMask,
  180.            GrabModeAsync,
  181.            GrabModeSync,
  182.            None,
  183.            XCreateFontCursor(XtDisplay(toplevel), XC_crosshair),
  184.            CurrentTime);
  185.  
  186.   while (True) {
  187.     XtAppNextEvent(XtWidgetToApplicationContext(toplevel), &ev);
  188.     if (ev.type == ButtonPress) {
  189.       break;
  190.     } else {
  191.       XtDispatchEvent(&ev);
  192.     }
  193.   }
  194.  
  195.   if (ev.type != ButtonPress) {
  196.     fprintf(stderr, "Impossible.\n");
  197.     exit(1);
  198.   }
  199.   last = XDefaultRootWindow(XtDisplay(toplevel));
  200.   chosen = last;
  201.   while (chosen != None) {
  202.     XQueryPointer(XtDisplay(toplevel), last,  &ignorew, &chosen,
  203.           &ignore, &ignore, &ignore, &ignore, &ignoreu);
  204.     if (chosen != None)
  205.       last = chosen;
  206.   }
  207.   XUngrabPointer(XtDisplay(toplevel), CurrentTime);
  208.   choose_x = ev.xbutton.x;
  209.   choose_y = ev.xbutton.y;
  210.   if (!cpick) {
  211.     createCpick(last);
  212.     first = True;
  213.   } else {
  214.     first = False;
  215.   }
  216.   if (picking) {
  217.     x = ((XButtonEvent *) &ev)->x_root;
  218.     y = ((XButtonEvent *) &ev)->y_root;
  219.     newpix = XGetPixel(XGetImage(XtDisplay(toplevel), 
  220.                  XRootWindowOfScreen(XDefaultScreenOfDisplay(XtDisplay(toplevel))),
  221.                  x, y, 1, 1,
  222.                  512-1 /* yuck dependency */, ZPixmap),
  223.                0, 0);
  224.     for (each=0; each<=realfree; each++) {
  225.       if (newpix == avail[each]) {
  226.     postDialog("That's one of the widget's colormap cells.  Pick another.");
  227.     XBell(XtDisplay(cmd), 0);
  228.     doSelect(cmd, NULL, position);
  229.     return;
  230.       }
  231.     }
  232.     current.pixel = newpix;
  233.     XQueryColor(XtDisplay(toplevel), cmap, ¤t);
  234.     allocated.red = current.red;
  235.     allocated.green = current.green;
  236.     allocated.blue = current.blue;
  237.     XSync(XtDisplay(toplevel), 0);
  238.   }
  239.   if (picking) {
  240.     /* generates error if can't allocate */
  241.     XStoreColor(XtDisplay(toplevel), cmap, ¤t);
  242.     XSync(XtDisplay(toplevel), 0);
  243.     if (picking) {
  244.       XtSetValues(cpick, setargs, XtNumber(setargs));
  245.       XtUnmanageChild(dialog);
  246.       if (first) {
  247.     XtRealizeWidget(realtop);
  248.     XSetWindowColormap(XtDisplay(realtop), XtWindow(realtop), cmap);
  249.     XSetWindowColormap(XtDisplay(toplevel), XtWindow(toplevel), cmap);
  250.     XSetWindowColormap(XtDisplay(cpick), XtWindow(cpick), cmap);
  251.     XSetWindowColormap(XtDisplay(dialog), XtWindow(XtParent(dialog)),
  252.                cmap);
  253.       }
  254.       picking = FALSE;
  255.       if (doMotif) {
  256.     bgColor.pixel = current.pixel;
  257.     bgColor.red = mapv[current.pixel].red;
  258.     bgColor.green = mapv[current.pixel].green;
  259.     bgColor.blue = mapv[current.pixel].blue;
  260.     (*colorProc)(&bgColor, &fgColor, &selectColor, &topColor,
  261.              &bottomColor);
  262.     for (each=0; each<numpixels; each++) {
  263.       for (each2=0; each2<=realfree; each2++) {
  264.         if (mapv[each].pixel == avail[each2]) {
  265.           break;
  266.         }
  267.       }
  268.       if (each2 > realfree) {
  269.         if (!haveFg &&
  270.         SAME_COLOR(mapv[each].red, fgColor.red) &&
  271.         SAME_COLOR(mapv[each].green, fgColor.green) &&
  272.         SAME_COLOR(mapv[each].blue, fgColor.blue)) {
  273.           fgColor.pixel = mapv[each].pixel;
  274. /* Don't know what this color is used for
  275.              haveFg = True;
  276. */
  277.         } else if (!haveSelect &&
  278.                SAME_COLOR(mapv[each].red, selectColor.red) &&
  279.                SAME_COLOR(mapv[each].green, selectColor.green) &&
  280.                SAME_COLOR(mapv[each].blue, selectColor.blue)) {
  281.           selectColor.pixel = mapv[each].pixel;
  282. /* Don't know what this color is used for
  283.           haveSelect = True;
  284. */
  285.         } else if (!haveTop &&
  286.                SAME_COLOR(mapv[each].red, topColor.red) &&
  287.                SAME_COLOR(mapv[each].green, topColor.green) &&
  288.                SAME_COLOR(mapv[each].blue, topColor.blue)) {
  289.           topColor.pixel = mapv[each].pixel;
  290.           haveTop = True;    
  291.         } else if (!haveBottom &&
  292.                SAME_COLOR(mapv[each].red, bottomColor.red) &&
  293.                SAME_COLOR(mapv[each].green, bottomColor.green) &&
  294.                SAME_COLOR(mapv[each].blue, bottomColor.blue)) {
  295.           bottomColor.pixel = mapv[each].pixel;
  296.           haveBottom = True;
  297.         }
  298.       }
  299.     }
  300.       }
  301.       bframe = CpickGetBoxFrame(cpick);
  302.       count = 0;
  303.       if (haveTop) {
  304.     XtSetArg(args[count], XmNtopShadowColor, topColor.pixel);  count++;
  305.     XtSetArg(args[count], XmNtopShadowPixmap,
  306.          XmUNSPECIFIED_PIXMAP);  count++;
  307.       } else {
  308.     XtSetArg(args[count], XmNtopShadowColor, current.pixel);  count++;
  309.     XtSetArg(args[count], XmNtopShadowPixmap,
  310.          XmUNSPECIFIED_PIXMAP);  count++;
  311.       }
  312.       if (haveBottom) {
  313.     XtSetArg(args[count], XmNbottomShadowColor,
  314.          bottomColor.pixel);  count++;
  315.     XtSetArg(args[count], XmNbottomShadowPixmap,
  316.          XmUNSPECIFIED_PIXMAP);  count++;
  317.       } else {
  318.     XtSetArg(args[count], XmNbottomShadowColor,
  319.          current.pixel);  count++;
  320.     XtSetArg(args[count], XmNbottomShadowPixmap,
  321.          XmUNSPECIFIED_PIXMAP);  count++;
  322.       }
  323.       XtSetValues(bframe, args, count);
  324.     } else {
  325.       doSelect(cmd, NULL, position);
  326.     }
  327.   } else {
  328.     doSelect(cmd, NULL, position);
  329.   }
  330. }
  331.  
  332. doOk(cmd, cdata, position)
  333.      Widget cmd;
  334.      XtPointer cdata;
  335.      float position;
  336. {
  337.   restoreCmap();
  338.   exit(0);
  339. }
  340.  
  341. doHelp(cmd, cdata, position)
  342.      Widget cmd;
  343.      XtPointer cdata;
  344.      float position;
  345. {
  346.   static Widget info = NULL;
  347.   XmString title, message;
  348.  
  349.   if (!info) {
  350.     count = 0;
  351.     title = XmStringCreateSimple("Pixedit Help");
  352.     XtSetArg(args[count], XmNdialogTitle, title);  count++;
  353.     message = XmStringCreateSimple(HELP_STRING);
  354.     XtSetArg(args[count], XmNmessageString, message);  count++;
  355.     info = XmCreateInformationDialog(toplevel, "info", args, count);
  356.     XtUnmanageChild(XmMessageBoxGetChild(info, XmDIALOG_CANCEL_BUTTON));
  357.     XtUnmanageChild(XmMessageBoxGetChild(info, XmDIALOG_HELP_BUTTON));
  358.     XmStringFree(title);
  359.     XmStringFree(message);
  360.   }
  361.   XtManageChild(info);
  362. }
  363.  
  364. doChange(cmd, cdata, position)
  365.      Widget cmd;
  366.      XtPointer cdata;
  367.      float position;
  368. {
  369.   saveCurrent();
  370.   if (haveFg || haveSelect || haveTop || haveBottom) {
  371.     XColor bgColor;
  372.  
  373.     bgColor.pixel = current.pixel;
  374.     bgColor.red = current.red;
  375.     bgColor.green = current.green;
  376.     bgColor.blue = current.blue;
  377.     (*colorProc)(&bgColor, &fgColor, &selectColor, &topColor, &bottomColor);
  378.     if (haveFg) {
  379.       XStoreColor(XtDisplay(toplevel), cmap, &fgColor);
  380.     }
  381.     if (haveSelect) {
  382.       XStoreColor(XtDisplay(toplevel), cmap, &selectColor);
  383.     }
  384.     if (haveTop) {
  385.       XStoreColor(XtDisplay(toplevel), cmap, &topColor);
  386.     }
  387.     if (haveBottom) {
  388.       XStoreColor(XtDisplay(toplevel), cmap, &bottomColor);
  389.     }
  390.   }
  391. }
  392.  
  393. doRestore(cmd, cdata, position)
  394.      Widget cmd;
  395.      XtPointer cdata;
  396.      float position;
  397. {
  398.   restoreCmap();
  399.   XQueryColor(XtDisplay(toplevel), cmap, ¤t);
  400.   allocated.red = current.red;
  401.   allocated.green = current.green;
  402.   allocated.blue = current.blue;
  403.   XtSetValues(cpick, setargs, XtNumber(setargs));
  404. }
  405.  
  406. int createCmap(num, wcmap, visual)
  407. int num;
  408. Colormap wcmap;
  409. Visual *visual;
  410. {
  411.   Display *dpy;
  412.   int screen, each, real;
  413.   XSetWindowAttributes xswa;
  414.  
  415.   real = num+1;
  416.  
  417.   dpy = XtDisplay(toplevel);
  418.   screen = XDefaultScreen(XtDisplay(toplevel));
  419.  
  420.   for (each=0; each<maxpixels; each++) {
  421.     mapv[each].pixel = each;
  422.     mapv[each].flags = (DoRed | DoGreen | DoBlue);
  423.   }
  424.   XQueryColors(dpy, wcmap, mapv, numpixels);
  425.  
  426.   while ((real > 1) &&
  427.      (!XAllocColorCells(dpy, wcmap, FALSE, NULL, 0, avail,
  428.                 real+1))) {
  429.     real--;
  430.   }
  431.  
  432.   if (real <= 1) {
  433.     fprintf(stderr, "Sorry, can't allocate enuf colormap cells.\n");
  434.     exit(1);
  435.   }
  436.  
  437.   cmap = XCreateColormap(dpy, XRootWindow(dpy,screen),
  438.              visual, AllocNone);
  439.  
  440.   XAllocColorCells(dpy, cmap, FALSE, NULL, 0, got, numpixels);
  441.   XStoreColors(dpy,cmap,mapv,numpixels);
  442.   XFreeColors(dpy, cmap, avail, real, 0);
  443.   allocated = mapv[avail[real]];
  444.  
  445.   XInstallColormap(dpy,cmap);
  446.  
  447.   return real-1;
  448. }
  449.  
  450. errorHandler(dpy, event)
  451. Display *dpy;
  452. XErrorEvent *event;
  453. {
  454.   char buf[256];
  455.  
  456.   if ((event->error_code == BadAccess) ||
  457.       (event->request_code == X_QueryColors)) {
  458.     postDialog("Can't allocate that colormap cell.  Pick another.");
  459.     picking = FALSE;
  460.   } else {
  461.     XGetErrorText(dpy, event->error_code, buf, 256);
  462.     fprintf(stderr, "X protocol error detected by server: %s\n", buf);
  463.     fprintf(stderr, "  Failed request major op code %d\n",
  464.         (int) event->request_code);
  465.     exit(1);
  466.   }
  467. }
  468.  
  469. createCpick(win)
  470. Window win;
  471. {
  472.   static Arg mainargs[] = {
  473.     {XmNcmap, NULL},
  474. #ifdef USE_COLORS
  475.     {XmNuseColors, TRUE},
  476. #else
  477.     {XmNuseColors, FALSE},
  478. #endif
  479.     {XmNnearPixels, NULL},
  480.     {XmNallocated, (XtArgVal) &allocated},
  481.     {XmNtopAttachment, XmATTACH_FORM},
  482.     {XmNbottomAttachment, XmATTACH_FORM},
  483.     {XmNleftAttachment, XmATTACH_FORM},
  484.     {XmNrightAttachment, XmATTACH_FORM},
  485.     {XmNokLabel, (XtArgVal) "Quit"},
  486.     {XmNborderWidth, (XtArgVal) 0},
  487.   };
  488.   
  489.   XVisualInfo *vip, viproto, *bestvip;
  490.   XWindowAttributes xwa;
  491.   int nvi, i;
  492.   Dimension cw, ch;
  493.   Position x, y;
  494.  
  495.   XGetWindowAttributes(XtDisplay(toplevel), win, &xwa);
  496.   viproto.visual = xwa.visual;
  497.   viproto.class = PseudoColor;
  498.   vip = XGetVisualInfo(XtDisplay(toplevel), VisualClassMask, &viproto, &nvi);
  499.   if (!nvi || !xwa.colormap) {
  500.     postDialog("Sorry, that window doesn't have a colormap to edit (no PseudoColor visual).  Pick another.");
  501.     XBell(XtDisplay(toplevel), 0);
  502.     picking = FALSE;
  503.   } else {
  504. /* First try to find a visual that matches the selected window's visual */
  505.     bestvip = (XVisualInfo *) NULL;
  506.     for (i=0; i<nvi; i++) {
  507.       if (xwa.visual == vip[i].visual) {
  508.     bestvip = vip+i;
  509.       }
  510.     }
  511. /* Otherwise, find the pseudocolor visual with the most colormap entries,
  512.    but within our hardcoded limit */
  513.     if (!bestvip || bestvip->colormap_size > MAXPIXELS) {
  514.       bestvip = vip;
  515.       for (i=1; i<nvi; i++) {
  516.     if (bestvip->colormap_size < vip[i].colormap_size &&
  517.             vip[i].colormap_size <= MAXPIXELS) {
  518.       bestvip = vip+i;
  519.     }
  520.       }
  521.     }
  522.     numpixels = bestvip->colormap_size;
  523.     maxpixels = 1;
  524.     while (maxpixels < numpixels) {
  525.       maxpixels = maxpixels*2;
  526.     }
  527.     
  528.     if (numpixels < 11) {
  529.       fprintf(stderr, "Sorry, you don't have enough colormap cells.\n");
  530.       exit(1);
  531.     } else if (numpixels < 58) {
  532.       mainargs[1].value = (XtArgVal) FALSE;
  533.       mainargs[2].value = (XtArgVal) 4;
  534.       numfree = COLORLESSPIXELS+4;
  535.     } else if (numpixels < 136) {
  536. #ifdef USE_COLORS
  537.       mainargs[1].value = (XtArgVal) TRUE;
  538.       mainargs[2].value = (XtArgVal) 25;
  539.       numfree = NECESSARYPIXELS+25;
  540. #else
  541.       mainargs[1].value = (XtArgVal) FALSE;
  542.       mainargs[2].value = (XtArgVal) 25;
  543.       numfree = COLORLESSPIXELS+25;
  544. #endif
  545.     } else {
  546. #ifdef USE_COLORS
  547.       mainargs[1].value = (XtArgVal) TRUE;
  548.       mainargs[2].value = (XtArgVal) 64;
  549.       numfree = NECESSARYPIXELS+64;
  550. #else
  551.       mainargs[1].value = (XtArgVal) FALSE;
  552.       mainargs[2].value = (XtArgVal) 64;
  553.       numfree = COLORLESSPIXELS+64;
  554. #endif
  555.     }
  556.     
  557.     realfree = createCmap(numfree, xwa.colormap, bestvip->visual);
  558.     XFree((char *) vip);
  559.     
  560.     mainargs[0].value = (XtArgVal) cmap;
  561.     if (realfree != numfree)
  562.       if (mainargs[1].value == (XtArgVal) TRUE)
  563.     mainargs[2].value = (XtArgVal) realfree-NECESSARYPIXELS;
  564.       else
  565.     mainargs[2].value = (XtArgVal) realfree-COLORLESSPIXELS;
  566.     
  567.     cpick = XtCreateManagedWidget(argv0, cpickWidgetClass,
  568.                   toplevel, mainargs, XtNumber(mainargs));
  569.     XtAddCallback(cpick, XmNselectProc, (XtCallbackProc) doSelect, NULL);
  570.     XtAddCallback(cpick, XmNokProc, (XtCallbackProc) doOk, NULL);
  571.     XtAddCallback(cpick, XmNhelpProc, (XtCallbackProc) doHelp, NULL);
  572.     XtAddCallback(cpick, XmNchangeProc, (XtCallbackProc) doChange, NULL);
  573.     XtAddCallback(cpick, XmNrestoreProc, (XtCallbackProc) doRestore, NULL);
  574.     
  575.     cw = getD(cpick, XmNwidth);
  576.     ch = getD(cpick, XmNheight);
  577.     XGetWindowAttributes(XtDisplay(cpick),
  578.              XDefaultRootWindow(XtDisplay(cpick)), &xwa);
  579.     x = choose_x-(Position) (cw/2);
  580.     y = choose_y-(Position) (ch/2);
  581.     if (x < 0) {
  582.       x = 0;
  583.     } else if (x > xwa.width-cw) {
  584.       x = xwa.width-cw;
  585.     }
  586.     if (y < 0) {
  587.       y = 0;
  588.     } else if (y > xwa.height-ch) {
  589.       y = xwa.height-ch;
  590.     }
  591.     
  592.     XtMoveWidget(realtop, x, y);
  593.   }
  594. }
  595.  
  596. main(argc, argv)
  597.     int argc;
  598.     char **argv;
  599. {
  600.   int each;
  601.   XmString title;
  602.   
  603.   argv0 = argv[0];
  604.   allocated.flags = current.flags = DoRed | DoGreen | DoBlue;
  605.   
  606.   realtop = XtInitialize(argv[0], "Pixedit", cmdOptions, XtNumber(cmdOptions),
  607.              &argc, argv);
  608.  
  609.   if (argc != 1) {
  610.     usage();
  611.     exit(1);
  612.   }
  613.  
  614. #ifdef USE_SCHEMES
  615.   VkLoadScheme(XtDisplay(realtop), argv[0], "Pixedit");
  616. #endif
  617.  
  618.   count = 0;
  619.   toplevel = XmCreateForm(realtop, "form", args, count);
  620.   XtManageChild(toplevel);
  621.   
  622.   if (XDisplayPlanes(XtDisplay(toplevel),
  623.              XDefaultScreen(XtDisplay(toplevel))) == 1) {
  624.     fprintf(stderr, "Sorry, you need a color display.\n");
  625.     exit(1);
  626.   }
  627.  
  628.   XSetErrorHandler(errorHandler);
  629.   
  630.   doMotif = (XGetDefault(XtDisplay(toplevel), argv[0], "noMotif") == NULL);
  631.   if (doMotif) {
  632.     colorProc = XmGetColorCalculation();
  633.     fgColor.flags = selectColor.flags = topColor.flags = bottomColor.flags =
  634.       DoRed | DoGreen | DoBlue;
  635.   }
  636.  
  637.   count = 0;
  638.   title = XmStringCreateSimple("Pixedit");
  639.   XtSetArg(args[count], XmNdialogTitle, title);  count++;
  640.   dialog = XmCreateMessageDialog(toplevel, "dialog", args, count);
  641.   XmStringFree(title);
  642.   XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_DEFAULT_BUTTON));
  643.   XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON));
  644.   XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
  645.  
  646.   doSelect(toplevel, toplevel, NULL);
  647.  
  648.   XtMainLoop();
  649. }
  650.